.TH std::future::get 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::future::get \- std::future::get

.SH Synopsis
   Main template
   T get();                         \fB(1)\fP \fI(since C++11)\fP
   std::future<T&> specializations
   T& get();                        \fB(2)\fP \fI(since C++11)\fP
   std::future<void> specialization
   void get();                      \fB(3)\fP \fI(since C++11)\fP

   The get member function waits (by calling wait()) until the shared state is ready,
   then retrieves the value stored in the shared state (if any). Right after calling
   this function, valid() is false.

   If valid() is false before the call to this function, the behavior is undefined.

.SH Return value

   1) The value v stored in the shared state, as std::move(v).
   2) The reference stored as value in the shared state.
   3) \fI(none)\fP

.SH Exceptions

   If an exception was stored in the shared state referenced by the future (e.g. via a
   call to std::promise::set_exception()) then that exception will be thrown.

.SH Notes

   The C++ standard recommends the implementations to detect the case when valid() is
   false before the call and throw a std::future_error with an error condition of
   std::future_errc::no_state.

.SH Example


// Run this code

 #include <chrono>
 #include <future>
 #include <iostream>
 #include <string>
 #include <thread>

 std::string time()
 {
     static auto start = std::chrono::steady_clock::now();
     std::chrono::duration<double> d = std::chrono::steady_clock::now() - start;
     return "[" + std::to_string(d.count()) + "s]";
 }

 int main()
 {
     using namespace std::chrono_literals;

     {
         std::cout << time() << " launching thread\\n";
         std::future<int> f = std::async(std::launch::async, []
         {
             std::this_thread::sleep_for(1s);
             return 7;
         });
         std::cout << time() << " waiting for the future, f.valid() = "
                   << f.valid() << '\\n';
         int n = f.get();
         std::cout << time() << " f.get() returned " << n << ", f.valid() = "
                   << f.valid() << '\\n';
     }

     {
         std::cout << time() << " launching thread\\n";
         std::future<int> f = std::async(std::launch::async, []
         {
             std::this_thread::sleep_for(1s);
             return true ? throw std::runtime_error("7") : 7;
         });
         std::cout << time() << " waiting for the future, f.valid() = "
                   << f.valid() << '\\n';

         try
         {
             int n = f.get();
             std::cout << time() << " f.get() returned " << n
                       << ", f.valid() = " << f.valid() << '\\n';
         }
         catch (const std::exception& e)
         {
             std::cout << time() << " caught exception " << e.what()
                       << ", f.valid() = " << f.valid() << '\\n';
         }
     }
 }

.SH Possible output:

 [0.000004s] launching thread
 [0.000461s] waiting for the future, f.valid() = 1
 [1.001156s] f.get() returned with 7, f.valid() = 0
 [1.001192s] launching thread
 [1.001275s] waiting for the future, f.valid() = 1
 [2.002356s] caught exception 7, f.valid() = 0

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

      DR    Applied to              Behavior as published              Correct behavior
   LWG 2096 C++11      overload \fB(1)\fP needed to check whether T is       not required
                       MoveAssignable

.SH See also

   valid checks if the future has a shared state
         \fI(public member function)\fP
